Оптимізація Pandas DataFrame: Використання пам'яті та налаштування продуктивності

Pandas — це потужна бібліотека Python для маніпулювання та аналізу даних. Однак під час роботи з великими наборами даних Pandas DataFrame можуть споживати значний обсяг пам'яті та демонструвати низьку продуктивність. Ця стаття є повним посібником з оптимізації Pandas DataFrame як для використання пам'яті, так і для підвищення продуктивності, що дозволить вам ефективніше обробляти більші набори даних.

Розуміння використання пам'яті в Pandas DataFrame

Перш ніж занурюватися в техніки оптимізації, важливо зрозуміти, як Pandas DataFrame зберігають дані в пам'яті. Кожен стовпець у DataFrame має певний тип даних, який визначає обсяг пам'яті, необхідний для зберігання його значень. Поширені типи даних включають:

• int64: 64-бітні цілі числа (за замовчуванням для цілих чисел)
• float64: 64-бітні числа з плаваючою комою (за замовчуванням для чисел з плаваючою комою)
• object: об'єкти Python (використовується для рядків та змішаних типів даних)
• category: категоріальні дані (ефективно для повторюваних значень)
• bool: булеві значення (True/False)
• datetime64: значення дати та часу

Тип даних object часто є найбільш ресурсомістким, оскільки він зберігає вказівники на об'єкти Python, які можуть бути значно більшими за примітивні типи даних, такі як цілі числа або числа з плаваючою комою. Рядки, навіть короткі, при зберіганні як `object`, споживають набагато більше пам'яті, ніж необхідно. Аналогічно, використання `int64`, коли було б достатньо `int32`, марнує пам'ять.

Приклад: Перевірка використання пам'яті DataFrame

Ви можете використовувати метод memory_usage() для перевірки використання пам'яті DataFrame:

            import pandas as pd
import numpy as np

data = {
    'col1': np.random.randint(0, 1000, 100000),
    'col2': np.random.rand(100000),
    'col3': ['A', 'B', 'C'] * (100000 // 3 + 1)[:100000],
    'col4': ['This is a long string'] * 100000
}

df = pd.DataFrame(data)

memory_usage = df.memory_usage(deep=True)
print(memory_usage)
print(df.dtypes)

            

              
                Copy
              
            
          

Аргумент deep=True гарантує, що використання пам'яті об'єктами (наприклад, рядками) розраховується точно. Без `deep=True`, буде розраховано лише пам'ять для вказівників, а не для даних, що лежать в їх основі.

Оптимізація типів даних

Одним з найефективніших способів зменшити використання пам'яті є вибір найбільш відповідних типів даних для стовпців вашого DataFrame. Ось кілька поширених технік:

1. Пониження розрядності числових типів даних

Якщо ваші стовпці з цілими числами або числами з плаваючою комою не вимагають повного діапазону 64-бітної точності, ви можете понизити їх до менших типів даних, таких як int32, int16, float32 або float16. Це може значно зменшити використання пам'яті, особливо для великих наборів даних.

Приклад: Розглянемо стовпець, що представляє вік, який навряд чи перевищить 120. Зберігати його як `int64` є марнотратством; `int8` (діапазон від -128 до 127) буде більш доцільним.

            def downcast_numeric(df):
    """Downcasts numeric columns to the smallest possible data type."""
    for col in df.columns:
        if pd.api.types.is_integer_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='integer')
        elif pd.api.types.is_float_dtype(df[col]):
            df[col] = pd.to_numeric(df[col], downcast='float')
    return df

df = downcast_numeric(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

Функція pd.to_numeric() з аргументом downcast використовується для автоматичного вибору найменшого можливого типу даних, який може представити значення у стовпці. `copy()` дозволяє уникнути модифікації оригінального DataFrame. Завжди перевіряйте діапазон значень у ваших даних перед пониженням розрядності, щоб не втратити інформацію.

2. Використання категоріальних типів даних

Якщо стовпець містить обмежену кількість унікальних значень, ви можете перетворити його на тип даних category. Категоріальні типи даних зберігають кожне унікальне значення лише один раз, а потім використовують цілочисельні коди для представлення значень у стовпці. Це може значно зменшити використання пам'яті, особливо для стовпців з високою часткою повторюваних значень.

Приклад: Розглянемо стовпець, що представляє коди країн. Якщо ви маєте справу з обмеженим набором країн (наприклад, тільки країни Європейського Союзу), зберігання цього як категорії буде набагато ефективнішим, ніж зберігання у вигляді рядків.

            def optimize_categories(df):
    """Converts object columns with low cardinality to categorical type."""
    for col in df.columns:
        if df[col].dtype == 'object':
            num_unique_values = len(df[col].unique())
            num_total_values = len(df[col])
            if num_unique_values / num_total_values < 0.5:
                df[col] = df[col].astype('category')
    return df

df = optimize_categories(df.copy())
print(df.memory_usage(deep=True))
print(df.dtypes)

            

              
                Copy
              
            
          

Цей код перевіряє, чи кількість унікальних значень у стовпці типу object менша за 50% від загальної кількості значень. Якщо так, він перетворює стовпець на категоріальний тип даних. Поріг у 50% є умовним і може бути скоригований залежно від конкретних характеристик ваших даних. Цей підхід є найбільш вигідним, коли стовпець містить багато повторюваних значень.

3. Уникнення типів даних Object для рядків

Як зазначалося раніше, тип даних object часто є найбільш ресурсомістким, особливо при використанні для зберігання рядків. Якщо можливо, намагайтеся уникати використання типів даних object для рядкових стовпців. Категоріальні типи є кращими для рядків з низькою кардинальністю. Якщо кардинальність висока, подумайте, чи можна представити рядки числовими кодами або чи можна взагалі уникнути рядкових даних.

Якщо вам потрібно виконувати рядкові операції над стовпцем, можливо, доведеться залишити його як тип object, але подумайте, чи можна виконати ці операції заздалегідь, а потім перетворити на більш ефективний тип.

4. Дані дати та часу

Використовуйте тип даних `datetime64` для інформації про дату та час. Переконайтеся, що роздільна здатність є доречною (наносекундна роздільна здатність може бути непотрібною). Pandas дуже ефективно обробляє дані часових рядів.

Оптимізація операцій з DataFrame

Окрім оптимізації типів даних, ви також можете покращити продуктивність Pandas DataFrame, оптимізувавши операції, які ви над ними виконуєте. Ось кілька поширених технік:

1. Векторизація

Векторизація — це процес виконання операцій над цілими масивами або стовпцями одночасно, а не ітерація по окремих елементах. Pandas високо оптимізований для векторизованих операцій, тому їх використання може значно покращити продуктивність. Уникайте явних циклів, коли це можливо. Вбудовані функції Pandas, як правило, набагато швидші за еквівалентні цикли Python.

Приклад: Замість ітерації по стовпцю для обчислення квадрата кожного значення, використовуйте функцію pow():

            # Inefficient (using a loop)
import time

start_time = time.time()
results = []
for value in df['col2']:
    results.append(value ** 2)
df['col2_squared_loop'] = results
end_time = time.time()
print(f"Loop time: {end_time - start_time:.4f} seconds")

# Efficient (using vectorization)
start_time = time.time()
df['col2_squared_vectorized'] = df['col2'] ** 2
end_time = time.time()
print(f"Vectorized time: {end_time - start_time:.4f} seconds")


            

              
                Copy
              
            
          

Векторизований підхід зазвичай на порядки швидший за підхід на основі циклу.

2. Обережне використання `apply()`

Метод apply() дозволяє застосувати функцію до кожного рядка або стовпця DataFrame. Однак він, як правило, повільніший за векторизовані операції, оскільки передбачає виклик функції Python для кожного елемента. Використовуйте apply() лише тоді, коли векторизовані операції неможливі.

Якщо ви все ж таки повинні використовувати `apply()`, намагайтеся максимально векторизувати функцію, яку ви застосовуєте. Розгляньте можливість використання декоратора `jit` з Numba для компіляції функції в машинний код для значного підвищення продуктивності.

            from numba import jit

@jit(nopython=True)
def my_function(x):
    return x * 2  # Example function

df['col2_applied'] = df['col2'].apply(my_function)

            

              
                Copy
              
            
          

3. Ефективний вибір стовпців

При виборі підмножини стовпців з DataFrame використовуйте наступні методи для оптимальної продуктивності:

• Прямий вибір стовпців: df[['col1', 'col2']] (найшвидший для вибору кількох стовпців)
• Булева індексація: df.loc[:, [True if col.startswith('col') else False for col in df.columns]] (корисно для вибору стовпців за умовою)

Уникайте використання df.filter() з регулярними виразами для вибору стовпців, оскільки це може бути повільніше за інші методи.

4. Оптимізація об'єднань (Joins та Merges)

Об'єднання та злиття DataFrame може бути обчислювально витратним, особливо для великих наборів даних. Ось кілька порад для оптимізації об'єднань та злиттів:

• Використовуйте відповідні ключі об'єднання: Переконайтеся, що ключі об'єднання мають однаковий тип даних та проіндексовані.
• Вказуйте тип об'єднання: Використовуйте відповідний тип об'єднання (наприклад, inner, left, right, outer) відповідно до ваших вимог. Внутрішнє об'єднання (inner join) зазвичай швидше за зовнішнє (outer join).
• Використовуйте `merge()` замість `join()`: Функція merge() є більш універсальною і часто швидшою за метод join().

Приклад:

            df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value1': [1, 2, 3, 4]})
df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value2': [5, 6, 7, 8]})

# Efficient inner join
df_merged = pd.merge(df1, df2, on='key', how='inner')

print(df_merged)

            

              
                Copy
              
            
          

5. Уникнення зайвого копіювання DataFrame

Багато операцій Pandas створюють копії DataFrame, що може бути ресурсомістким та забирати багато часу. Щоб уникнути зайвого копіювання, використовуйте аргумент inplace=True, коли це можливо, або присвоюйте результат операції назад до оригінального DataFrame. Будьте дуже обережні з `inplace=True`, оскільки це може маскувати помилки та ускладнювати налагодження. Часто безпечніше перепризначити, навіть якщо це трохи менш продуктивно.

Приклад:

            # Inefficient (creates a copy)
df_filtered = df[df['col1'] > 500]

# Efficient (modifies the original DataFrame in place - CAUTION)
df.drop(df[df['col1'] <= 500].index, inplace=True)

#SAFER - reassigns, avoids inplace
df = df[df['col1'] > 500]

            

              
                Copy
              
            
          

6. Обробка частинами та ітерація

Для надзвичайно великих наборів даних, які не вміщуються в пам'ять, розгляньте можливість обробки даних частинами. Використовуйте параметр `chunksize` при читанні даних з файлів. Ітеруйте по частинах і виконуйте аналіз для кожної частини окремо. Це вимагає ретельного планування, щоб забезпечити коректність аналізу, оскільки деякі операції вимагають обробки всього набору даних одночасно.

            # Read CSV in chunks
for chunk in pd.read_csv('large_data.csv', chunksize=100000):
    # Process each chunk
    print(chunk.shape)

            

              
                Copy
              
            
          

7. Використання Dask для паралельної обробки

Dask — це бібліотека для паралельних обчислень, яка бездоганно інтегрується з Pandas. Вона дозволяє обробляти великі DataFrame паралельно, що може значно покращити продуктивність. Dask ділить DataFrame на менші розділи та розподіляє їх між кількома ядрами або машинами.

            import dask.dataframe as dd

# Create a Dask DataFrame
ddf = dd.read_csv('large_data.csv')

# Perform operations on the Dask DataFrame
ddf_filtered = ddf[ddf['col1'] > 500]

# Compute the result (this triggers the parallel computation)
result = ddf_filtered.compute()

print(result.head())

            

              
                Copy
              
            
          

Індексація для швидшого пошуку

Створення індексу для стовпця може значно прискорити операції пошуку та фільтрації. Pandas використовує індекси для швидкого знаходження рядків, які відповідають певному значенню.

Приклад:

            # Set 'col3' as the index
df = df.set_index('col3')

# Faster lookup
value = df.loc['A']

print(value)

# Reset the index
df = df.reset_index()

            

              
                Copy
              
            
          

Однак створення занадто великої кількості індексів може збільшити використання пам'яті та сповільнити операції запису. Створюйте індекси лише для стовпців, які часто використовуються для пошуку або фільтрації.

Інші міркування

• Апаратне забезпечення: Розгляньте можливість оновлення вашого апаратного забезпечення (CPU, RAM, SSD), якщо ви постійно працюєте з великими наборами даних.
• Програмне забезпечення: Переконайтеся, що ви використовуєте останню версію Pandas, оскільки новіші версії часто містять покращення продуктивності.
• Профілювання: Використовуйте інструменти профілювання (наприклад, cProfile, line_profiler), щоб виявити вузькі місця у вашому коді.
• Формат зберігання даних: Розгляньте можливість використання більш ефективних форматів зберігання даних, таких як Parquet або Feather, замість CSV. Ці формати є стовпчастими і часто стиснутими, що призводить до менших розмірів файлів та швидшого читання/запису.

Висновок

Оптимізація Pandas DataFrame для використання пам'яті та підвищення продуктивності є ключовою для ефективної роботи з великими наборами даних. Вибираючи відповідні типи даних, використовуючи векторизовані операції та ефективно індексуючи ваші дані, ви можете значно зменшити споживання пам'яті та покращити продуктивність. Не забувайте профілювати свій код для виявлення вузьких місць у продуктивності та розгляньте можливість використання обробки частинами або Dask для надзвичайно великих наборів даних. Застосовуючи ці техніки, ви зможете розкрити весь потенціал Pandas для аналізу та маніпулювання даними.